/**
 * 统一跳转逻辑处理模块
 */

// 获取当前URL的参数
function getCurrentUrlParams() {
    const params = new URLSearchParams(window.location.search);
    return params.toString();
}

// 获取特定参数的值
function getUrlParameter(name) {
    const params = new URLSearchParams(window.location.search);
    return params.get(name);
}

// 构建跳转URL，保留原始参数并添加默认参数
function buildRedirectUrl(baseUrl, defaultParams = {}) {
    // 获取当前页面的所有参数
    const currentParams = new URLSearchParams(window.location.search);
    
    // 移除t参数，防止无限循环跳转
    currentParams.delete('t');
    
    // 创建新的URL对象
    const url = new URL(baseUrl, window.location.origin);
    
    // 将当前页面的参数添加到新URL中（除了t参数）
    for (const [key, value] of currentParams) {
        url.searchParams.set(key, value);
    }
    
    // 添加默认参数（仅当参数不存在时）
    for (const [key, value] of Object.entries(defaultParams)) {
        if (!url.searchParams.has(key)) {
            url.searchParams.set(key, value);
        }
    }
    
    return url.toString();
}

// 从后端获取站点配置
function fetchSiteConfig() {
    // 默认配置（兜底方案）
    const defaultConfig = {
        mainSite: 'https://2025.task2030.xyz/',
        backupSite: 'https://zjnh.yamhk.top/'
    };
    
    return new Promise((resolve) => {
        // 尝试从后端获取配置，添加时间戳防止缓存
        fetch(`/api/site-config?t=${Date.now()}`)
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                return response.json();
            })
            .then(data => {
                resolve({
                    mainSite: data.mainSite || defaultConfig.mainSite,
                    backupSite: data.backupSite || defaultConfig.backupSite
                });
            })
            .catch(error => {
                console.warn('获取站点配置失败，使用默认配置:', error);
                resolve(defaultConfig);
            });
    });
}

// 更新站点按钮的URL，确保包含当前页面的参数
function updateSiteButtonUrls() {
    // 获取当前页面的所有参数
    const currentParams = new URLSearchParams(window.location.search);
    
    // 异步获取站点配置并更新按钮
    fetchSiteConfig().then(config => {
        // 更新主站点按钮
        const mainSiteButton = document.getElementById('mainSiteButton');
        if (mainSiteButton) {
            const mainSiteUrl = new URL(config.mainSite, window.location.origin);
            
            // 添加当前页面的参数
            for (const [key, value] of currentParams) {
                mainSiteUrl.searchParams.set(key, value);
            }
            
            // 如果没有t参数，添加默认值
            if (!mainSiteUrl.searchParams.has('t')) {
                mainSiteUrl.searchParams.set('t', '000');
            }
            
            // 如果没有topic参数，添加默认值
            if (!mainSiteUrl.searchParams.has('topic')) {
                mainSiteUrl.searchParams.set('topic', '30000000');
            }
            
            mainSiteButton.href = mainSiteUrl.toString();
        }
        
        // 更新副站点按钮
        const backupSiteButton = document.getElementById('backupSiteButton');
        if (backupSiteButton) {
            const backupSiteUrl = new URL(config.backupSite, window.location.origin);
            
            // 添加当前页面的参数
            for (const [key, value] of currentParams) {
                backupSiteUrl.searchParams.set(key, value);
            }
            
            // 如果没有t参数，添加默认值
            if (!backupSiteUrl.searchParams.has('t')) {
                backupSiteUrl.searchParams.set('t', '000');
            }
            
            // 如果没有topic参数，添加默认值
            if (!backupSiteUrl.searchParams.has('topic')) {
                backupSiteUrl.searchParams.set('topic', '30000000');
            }
            
            backupSiteButton.href = backupSiteUrl.toString();
        }
    });
}

// 统一的自动跳转处理函数
function handleAutoRedirect(config) {
    const tParam = getUrlParameter('t');
    
    // 如果t=001，根据配置执行跳转
    if (tParam === '001') {
        // 默认配置
        const defaultConfig = {
            redirectUrl: 'https://2025.task2030.xyz/',
            bannerId: null,
            delay: 12000,
            target: '_blank',
            defaultParams: {t: '000', topic: '30000000'}
        };
        
        // 合并配置
        const finalConfig = Object.assign(defaultConfig, config);
        
        // 异步获取最新的站点配置
        fetchSiteConfig().then(config => {
            // 使用从后端获取的主站点URL或配置的URL
            const redirectUrl = config.mainSite || finalConfig.redirectUrl;
            
            // 构建跳转URL，保留原始参数并添加默认参数
            const targetUrl = buildRedirectUrl(redirectUrl, finalConfig.defaultParams);
            
            // 显示提示信息
            if (finalConfig.bannerId) {
                const statusBanner = document.getElementById(finalConfig.bannerId);
                if (statusBanner) {
                    statusBanner.className = 'mt-24 mb-6 success-banner text-white text-center py-3 text-sm font-medium mx-4';
                    statusBanner.innerHTML = '<i class="fa fa-info-circle mr-2"></i> 页面将在' + (finalConfig.delay/1000) + '秒后自动跳转';
                    statusBanner.style.display = 'block';
                }
            }
            
            // 延迟跳转
            setTimeout(function() {
                if (finalConfig.target === '_blank') {
                    window.open(targetUrl, finalConfig.target);
                } else {
                    window.location.href = targetUrl;
                }
            }, finalConfig.delay);
        });
    }
}

// 根据t参数值决定跳转页面 (适用于首页)
function handleIndexRedirect() {
    const tParam = getUrlParameter('t');
    
    // 定义t参数到页面的映射
    const tParamMap = {
        '001': 'module/index/helloWorld.html',
        '002': 'module/index/mx_junjie.html',
        'auto': 'module/index/mx_chat.html',
        // 可以方便地添加更多映射
        // '003': 'module/index/new_page.html',
        // '004': 'module/index/another_page.html'
    };
    
    // 默认跳转页面
    let redirectPage = 'module/index/mx_chat.html';
    
    // 如果t参数在映射中，则使用映射的页面
    if (tParam && tParamMap.hasOwnProperty(tParam)) {
        if (tParam === 'auto') {
            // 处理auto参数，跳转到聊天页面
            redirectPage = tParamMap[tParam];
        } else {
            redirectPage = tParamMap[tParam];
            // 移除t参数，防止无限循环跳转
            const urlParams = new URLSearchParams(window.location.search);
            urlParams.delete('t');
            const newQueryString = urlParams.toString();
            if (newQueryString) {
                redirectPage += '?' + newQueryString;
            }
        }
    } else if (!tParam) {
        // 如果没有t参数，跳转到聊天页面并添加t=000参数
        const urlParams = new URLSearchParams(window.location.search);
        urlParams.set('t', '000');
        const newQueryString = urlParams.toString();
        redirectPage += '?' + newQueryString;
    } else {
        // 如果t参数不在映射中，确保使用默认值000
        const urlParams = new URLSearchParams(window.location.search);
        urlParams.set('t', '000');
        const newQueryString = urlParams.toString();
        redirectPage += '?' + newQueryString;
    }
    
    // 快速跳转（100毫秒延迟）
    setTimeout(function() {
        window.location.href = redirectPage;
    }, 100);
}

// 检测站点是否可达
function checkSiteReachability(url) {
    return new Promise((resolve) => {
        // 使用图片探测方式替代fetch，避免CORS问题
        const img = new Image();
        
        // 设置图片的referrerPolicy以减少跨域问题
        img.referrerPolicy = "no-referrer";
        
        const timeoutId = setTimeout(() => {
            img.src = ''; // 取消加载
            resolve(false);
        }, 5000); // 5秒超时
        
        img.onload = function() {
            clearTimeout(timeoutId);
            resolve(true);
        };
        
        img.onerror = function() {
            clearTimeout(timeoutId);
            resolve(false);
        };
        
        // 尝试加载站点的favicon作为探测方式
        img.src = url.replace(/\/$/, '') + '/favicon.ico';
    });
}

// 更新按钮状态和提示信息
function updateButtonState(buttonId, isReachable, siteName) {
    const button = document.getElementById(buttonId);
    const statusElement = document.getElementById(buttonId + 'Status');
    
    if (button && statusElement) {
        if (isReachable) {
            // 站点可达，启用按钮
            button.classList.remove('btn-disabled');
            button.style.opacity = '1';
            button.style.pointerEvents = 'auto';
            statusElement.innerHTML = `<i class="fa fa-check-circle text-green-400 mr-2"></i>${siteName} 可访问`;
        } else {
            // 站点不可达，禁用按钮
            button.classList.add('btn-disabled');
            button.style.opacity = '0.5';
            button.style.pointerEvents = 'none';
            button.style.cursor = 'not-allowed';
            statusElement.innerHTML = `<i class="fa fa-times-circle text-red-400 mr-2"></i>${siteName} 不可访问`;
        }
    }
}

// 检测所有站点的可达性
async function checkAllSites() {
    const statusBanner = document.getElementById('siteStatusBanner');
    if (statusBanner) {
        statusBanner.className = 'mt-24 mb-6 warning-banner text-white text-center py-3 text-sm font-medium mx-4';
        statusBanner.innerHTML = '<i class="fa fa-spinner fa-spin mr-2"></i> 正在检测站点...';
        statusBanner.style.display = 'block';
    }
    
    // 异步获取站点配置
    const config = await fetchSiteConfig();
    
    // 定义站点URL（移除参数以避免CORS问题，但保持路径一致）
    const mainSiteUrl = config.mainSite;
    const backupSiteUrl = config.backupSite;
    
    // 检测两个站点的可达性
    const mainSiteReachable = await checkSiteReachability(mainSiteUrl);
    const backupSiteReachable = await checkSiteReachability(backupSiteUrl);
    
    // 更新客服在线状态
    updateServiceStatus(mainSiteReachable);
    
    // 更新按钮状态和提示信息
    updateButtonState('mainSiteButton', mainSiteReachable, '主站点');
    updateButtonState('backupSiteButton', backupSiteReachable, '副站点');
    
    // 当主站点可访问时，禁用副站点按钮并添加提示
    const backupSiteButton = document.getElementById('backupSiteButton');
    const backupSiteStatus = document.getElementById('backupSiteButtonStatus');
    if (mainSiteReachable && backupSiteButton && backupSiteStatus) {
        // 主站点可访问，禁用副站点按钮
        backupSiteButton.classList.add('btn-disabled');
        backupSiteButton.style.opacity = '0.5';
        backupSiteButton.style.pointerEvents = 'none';
        backupSiteButton.style.cursor = 'not-allowed';
        // 添加提示信息
        backupSiteStatus.innerHTML = `<i class="fa fa-info-circle text-blue-400 mr-2"></i>主站点可访问，建议优先使用主站点`;
    }
    
    // 更新状态横幅
    if (statusBanner) {
        if (mainSiteReachable || backupSiteReachable) {
            statusBanner.className = 'mt-24 mb-6 success-banner text-white text-center py-3 text-sm font-medium mx-4';
            statusBanner.innerHTML = '<i class="fa fa-check-circle mr-2"></i> 站点检测完成';
        } else {
            statusBanner.className = 'mt-24 mb-6 warning-banner text-white text-center py-3 text-sm font-medium mx-4';
            statusBanner.innerHTML = '<i class="fa fa-exclamation-triangle mr-2"></i> 所有站点暂时不可访问，请稍后再试';
        }
    }
}

// 更新客服在线状态
function updateServiceStatus(isMainSiteReachable) {
    const serviceStatus = document.getElementById('serviceStatus');
    const serviceStatusIcon = document.getElementById('serviceStatusIcon');
    const serviceStatusText = document.getElementById('serviceStatusText');
    
    if (serviceStatus && serviceStatusIcon && serviceStatusText) {
        if (isMainSiteReachable) {
            // 主站点可访问，客服在线
            serviceStatus.className = 'mt-4 inline-flex items-center px-4 py-2 rounded-full text-sm font-medium bg-green-100 text-green-800';
            serviceStatusIcon.innerHTML = '<i class="fa fa-circle text-green-500"></i>';
            serviceStatusText.textContent = '客服在线';
        } else {
            // 主站点不可访问，客服离线
            serviceStatus.className = 'mt-4 inline-flex items-center px-4 py-2 rounded-full text-sm font-medium bg-red-100 text-red-800';
            serviceStatusIcon.innerHTML = '<i class="fa fa-circle text-red-500"></i>';
            serviceStatusText.textContent = '客服暂时离线';
        }
    }
}

// 为微信二维码图片添加点击跳转功能
function setupWxQRCodeRedirect() {
    const wxQRCode = document.getElementById('wxQRCode');
    
    if (wxQRCode) {
        wxQRCode.addEventListener('click', function() {
            // 异步获取站点配置并跳转
            fetchSiteConfig().then(config => {
                // 优先跳转到主站点，如果主站点不可达则跳转到副站点
                checkSiteReachability(config.mainSite).then(mainSiteReachable => {
                    const targetUrl = mainSiteReachable 
                        ? buildRedirectUrl(config.mainSite, {t: '000', topic: '30000000'})
                        : buildRedirectUrl(config.backupSite, {t: '000', topic: '30000000'});
                    
                    console.log('点击微信二维码，跳转到站点:', targetUrl);
                    window.open(targetUrl, '_blank');
                });
            });
        });
    }
}

// 导出函数供外部使用
window.RedirectUtils = {
    getCurrentUrlParams,
    getUrlParameter,
    buildRedirectUrl,
    updateSiteButtonUrls,
    handleAutoRedirect,
    handleIndexRedirect,
    checkSiteReachability,
    updateButtonState,
    checkAllSites,
    updateServiceStatus,
    setupWxQRCodeRedirect,
    fetchSiteConfig
};